Last chance! 50% off unlimited learning
Sale ends in
These functions interpret an expression written in a SOP (sum of products) form, for both
crisp and multivalue QCA. The function translate()
translates the expression
into a standard (canonical) SOP form using a matrix of implicants, while
compute()
uses the first to compute the scores based on a particular dataset.
The function findRows()
takes a QCA expression written in SOP form, and
applies it on a truth table to find all rows that match the pattern in the expression.
For crisp sets notation, upper case letters are considered the presence of that causal condition, and lower case letters are considered the absence of the respective causal condition. Tilde is recognized as a negation, even in combination with upper/lower letters.
Functions similar to translate()
and compute()
have initially
been written by Jirka Lewandowski (2015) but the actual code in these functions has been
completely re-written and expanded with more extensive functionality (see details and
examples below).
The function sop()
transforms any expression (most notably a POS product
of sums) into a sum of products, minimizing it to the simplest equivalent logical expression.
translate(expression = "", snames = "", noflevels, data, ...)compute(expression = "", data, separate = FALSE)
findRows(expression = "", ttobj, remainders = FALSE)
sop(expression = "", snames = "", noflevels, data)
String: a QCA expression written in sum of products form.
A string containing the sets' names, separated by commas.
Numerical vector containing the number of levels for each set.
A dataset with binary cs, mv and fs data.
Logical, perform computations on individual, separate paths.
A truth table, an object of class "tt".
Logical, find remainders only.
Other arguments, mainly for backwards compatibility.
For the function translate()
, a matrix containing the implicants on the
rows and the set names on the columns, with the following codes:
0 | absence of a causal condition |
1 | presence of a causal condition |
-1 | causal condition was eliminated |
The matrix was also assigned a class "translate", to avoid printing the -1 codes. The mode of this matrix is character, to allow printing multiple levels in the same cell, such as "1,2".
A SOP ("sum of products") is also known as a DNF ("disjunctive normal form"), or in other
words a "union of intersections", for example A*D + B*c
.
The same expression can be written in multivalue notation: A{1}*D{1} + B{1}*C{0}
.
Both types of expressions are valid, and yield the same result on the same dataset.
For multivalue notation, causal conditions are expected as upper case letters, and they will be
converted to upper case by default. Expressions can contain multiple values to translate, separated
by a comma. If B was a multivalue causal condition, an expression could be:
A{1} + B{1,2}*C{0}
.
In this example, all values in B equal to either 1 or 2 will be converted to 1, and the rest of the (multi)values will be converted to 0.
The function automatically detects the use of tilde "~" as a negation for a particular
causal condition. ~A
does two things: it identifies the presence of causal
condition A
(because it was specified as upper case) and it recognizes that it
must be negated, because of the tilde. It works even combined with lower case names:
~a
, which is interpreted as A
.
To negate a multivalue condition using a tilde, the number of levels should be supplied
(see examples below). Improvements in version 2.5 allow for intersections
between multiple levels of the same condition. For a causal condition with 3 levels (0, 1 and 2)
the following expression ~A{0,2}*A{1,2}
is equivalent with A{1}
, while
A{0}*A{1}
results in the empty set.
The number of levels, as well as the set names can be automatically detected from a dataset via
the argument data
. Arguments snames
and noflevels
have
precedence over data
, when specified.
The use of the product operator *
is redundant when causal snames' names are single
letters (for example AD + Bc
), and is also redundant for multivalue data, where
product terms can be separated by using the curly brackets notation.
When causal snames are binary and their names have multiple letters (for example
AA + CC*bb
), the use of the product operator *
is preferable but the
function manages to translate an expression even without it (AA + CCbb
) by searching
deep in the space of the conditions' names, at the cost of slowing down for a high number of causal
conditions. For this reason, an arbitrary limit of 7 causal snames
is imposed, to write an
expression with.
Jirka Lewandowski (2015) QCAtools: Helper functions for QCA in R. R package version 0.1
# NOT RUN {
translate("A + B*C")
# same thing in multivalue notation
translate("A{1} + B{1}*C{1}")
# using upper/lower letters
translate("A + b*C")
# the negation with tilde is recognised
translate("~A + b*C")
# even in combination of upper/lower letters
translate("~A + ~b*C")
# and even for multivalue variables
# in multivalue notation, the product sign * is redundant
translate("C{1} + T{2} + T{1}V{0} + C{0}")
# negation of multivalue sets requires the number of levels
translate("~A{1} + ~B{0}*C{1}", noflevels = c(2, 2, 2))
# multiple values can be specified
translate("C{1} + T{1,2} + T{1}V{0} + C{0}")
# or even negated
translate("C{1} + ~T{1,2} + T{1}V{0} + C{0}", snames = "C, T, V", noflevels = c(2,3,2))
# if the expression does not contain the product sign *
# snames are required to complete the translation
translate("AB + cD", snames = "A, B, C, D")
# otherwise snames are not required
translate("PER*FECT + str*ing")
# snames are required
translate("PERFECT + string", snames = "PER, FECT, STR, ING")
# it works even with overlapping columns
# SU overlaps with SUB in SUBER, but the result is still correct
translate("SUBER + subset", "SU, BER, SUB, SET")
# }
# NOT RUN {
# error because combinations of condition names clash
translate("SUPER + subset", "SUP, ER, SU, PER, SUB, SET")
# }
# NOT RUN {
# to print _all_ codes from the standard output matrix
(obj <- translate("A + b*C"))
print(obj, original = TRUE) # also prints the -1 code
# for compute()
data(CVF)
compute("natpride + GEOCON", data = CVF)
# calculating individual paths
compute("natpride + GEOCON", data = CVF, separate = TRUE)
# for findRows()
data(LC)
ttLC <- truthTable(LC, "SURV", show.cases = TRUE)
findRows("DEV*ind*STB", ttLC)
findRows("DEV*ind*STB", ttLC, remainders = TRUE)
# for sop()
sop("(A + B)(A + ~B)") # result is "A"
# to force a certain order of the set names
sop("(URB + LIT*~DEV)(~LIT + ~DEV)", snames = "DEV, URB, LIT")
# multilevel conditions can also be specified (and negated)
sop("(A{1} + ~B{0})(B{1} + C{0})", snames = "A, B, C", noflevels = c(2, 3, 2))
# }
Run the code above in your browser using DataLab